<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <style>
        span {
            font-size: 20px;
            background-color: red;
            /* 行高为150% * 20 = 30 px，子元素会继承行高为30px */
            line-height: 150%;
            /* 行高为1.5*20 = 30 px，子元素只会继承line-height为1.5，再乘以子元素自身字体大小 */
            line-height: 1.5;
            /* 行内元素margin上下无效，左右有效 */
            margin: 20px;
            /*行内元素padding上下左右都有效 */
            padding: 5px;
        }
    </style>
</head>

<body>
    <span>我我我</span>
    <span>我我我</span>
    <!-- <div class="box"> -->
    <!-- <div class="ax"></div> -->
    <!-- <button>点我</button> -->
    <!-- <div class="bx"></div> -->
    <!-- </div> -->
</body>
<script>
    // let arr = [3, 5, 77, 0, -123, 544, -2];

    // 1.es6拓展运算符...
    // var maxVal = Math.max(...arr);
    // console.log(maxVal);



    // 2.apply(与方法1原理相同)
    // var maxVal = Math.max.apply(null, arr)
    // console.log(maxVal);


    // 3.for循环
    // var maxVal = arr[0];
    // for (let i = 0; i < arr.length - 1; i++) {
    //     maxVal = maxVal < arr[i + 1] ? arr[i + 1] : maxVal
    // }
    // console.log(maxVal);


    // 4.数组reduce
    // var maxVal = arr.reduce((num1, num2) => {
    //     return num1 > num2 ? num1 : num2
    // })
    // console.log(maxVal);

    // 5.数组sort()
    // arr.sort((a, b) => {
    //     return b - a; //降序排列
    // })
    // console.log(arr);

    //返回一个大于0的值，a在b位置的后面
    //返回一个等于0的值，a、b位置不变
    //返回一个小于0的值，a在b位置的前面


    // ***promise对象与async函数***
    function abc() {
        return new Promise((resolve, reject) => {
            console.log(111);
            // resolve()
            reject(99999)
        })
    }

    async function test() {
        console.log(123);
        try {
            let a = await abc();
        } catch (error) {
            console.log(error);
        }
        console.log(456);
    }
    test()

    // function useArguments() {
    //     console.log(arguments);
    //     arguments = Array.from(arguments);
    //     console.log(arguments);
    //     return arguments.reduce((total, num) => {
    //         return total + num;
    //     })
    // }
    // useArguments(1, 2, 3, 4, 5);

    // var num = 600000;
    // var res = num.toString(10) / Math.pow(10, 5);
    // if (res.toString().indexOf('.') == -1) {
    //     return 0;
    // } else {
    //     var idx = res.toString().indexOf('.');
    //     return res.toString()[idx + 1];
    // }
    //    console.log(parseInt(num,2));

    //toFixed(n)方法保留n位小数
    // var num = 1;
    // console.log(num.toFixed(2));


    var arr = [false, true, undefined, null, NaN, +0, -0, 1, {}, {}, 'a', 'a', NaN];
    var newArr = new Set(arr);
    console.log(newArr);

    // function c2b(e) {
    //     e = e.replace(" ", "+");
    //     var t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrtuvwxyz0123456789+/".indexOf(e);
    //     return t >= 0 ? t : 0;
    // }
    // function method1(e) {
    //     if (!e) return [];
    //     for (var t, a, r = [], n = 0, i = 0, l = 0, s = e.length; s > l; l++)
    //         t = c2b(e.charAt(l)),
    //             a = 6 & i ? 7 & i ^ 7 : 5,
    //             n |= t >> 5 - a << (7 ^ i) - a,
    //             64767 == n && 63 == t && (n == 65535),
    //             i > 25 && (i -= 32,
    //                 r[r.length] = n,
    //                 n = 0),
    //             n |= (t & (l << 5 - a) - 1) << (7 | i) + 4 + a,
    //             i += 6;
    //     return r;
    // }


    //防抖函数
    // function debounce(fun, wait = 1000) {
    //     let timeout;
    //     return function () {
    //         let that = this; // 保存this指向
    //         let args = arguments; // 保存arguments
    //         clearTimeout(timeout);
    //         timeout = setTimeout(function () {
    //             fun.apply(that, args); // 传递给fun内部
    //         }, wait);
    //     };
    // }

    var oBtn = document.querySelector('button');

    function debounce(func, wait = 1000) {
        let timeout;
        return function (a, b) {
            clearTimeout(timeout);
            timeout = setTimeout(() => { func(a, b) }, wait);
        }
    }
    function methodA(arg1, arg2) {
        console.log(arg1, arg2, "click");
    }
    var debounceA = debounce(methodA, 1000);
    ;
    // oBtn.onclick = function () {
    //     debounceA(1, 2)  
    // }

    // 节流函数
    function throttle(fn, wait) {
        // 上一次执行 fn 的时间
        let previous = 0;
        // 将 throttle 处理结果当作函数返回
        return function (...args) {
            // 获取当前时间，转换成时间戳，单位毫秒
            var now = new Date().getTime();
            // 将当前时间和上一次执行函数的时间进行对比
            // 大于等待时间就把 previous 设置为当前时间并执行函数 fn
            if (now - previous > wait) {
                previous = now;
                fn.apply(this, args);
            }
        }
    }
    console.log(new Date().getTime());
    function ab(a, b) {
        console.log(a, b);
        // console.log(111);
    }
    var abc = throttle(ab, 2000);
    oBtn.onclick = function () {
        abc(1, 2)
    }

    // 大数相加
    function sumBigNumber(a, b) {
        var res = '',
            temp = 0;
        a = a.split('');
        b = b.split('');
        while (a.length || b.length || temp) {
            temp += ~~a.pop() + ~~b.pop();
            res = (temp % 10) + res;
            temp = temp > 9;
        }
        return res.replace(/^0+/, '');
    }
    console.log(sumBigNumber('23132414314', '4125415145'));

    // 创建BigInt类型
    var num = Number.MAX_SAFE_INTEGER + 8;
    console.log(9007199254740999n);
    var b = BigInt('9007199254740999');
    var a = BigInt('10000000000000000');
    console.log(b);
    console.log(a + b);


    // ****判断类型方法：typeof, instanceof, Object.prototype.toString.call()
    // typeof只能判断基本类型除了null,引用类型和null都打印为object
    console.log(typeof null); // 打印为 object
    // instanceof只能判断基本类型,引用类型都是Object构造函数的实例
    console.log([] instanceof Object);


    // null与undefined 相等== 全等===
    console.log(null == undefined); // true
    console.log(null === undefined); // false
    console.log(!![]); // true
    console.log(!!{}); // true
    console.log(!!''); // false
    console.log(Number([])); // 0
    console.log(Number({})); // NaN
    console.log(Number('')); // 0
    console.log([] == '');  // true

    // 输出1~10，一秒一个。只能用let(块级作用域)或者自执行函数，用var就输出10个11了
    for (var i = 1; i <= 10; i++) {
        (i => {
            setTimeout(() => {
                console.log(i)
            }, 1000 * i);
        })(i)
    }
    for (let i = 1; i <= 10; i++) {
        setTimeout(() => {
            console.log(i)
        }, 1000 * i);
    }

    var j = 1;
    const temp = setInterval(() => {
        console.log(j);
        j++;
    }, 1000);
    setTimeout(() => {
        clearInterval(temp)
    }, 10010);

    function sleep(delay) {
        return new Promise((resolve, reject) => {
            setTimeout(() => {
                try {
                    resolve(1)
                } catch (e) {
                    reject(0)
                }
            }, delay);
        })
    }
    async function test() {
        for (var i = 0; i < 10; i++) {
            await sleep(1000);
            console.log(i);
        }
    }
    test()



</script>

</html>